home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / var / lib / python-support / python2.6 / orca / speechgenerator.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  43.5 KB  |  1,439 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''Utilities for obtaining speech utterances for objects.  In general,
  5. there probably should be a singleton instance of the SpeechGenerator
  6. class.  For those wishing to override the speech generators, however,
  7. one can create a new instance and replace/extend the speech generators
  8. as they see fit.'''
  9. __id__ = '$Id: speechgenerator.py 4471 2009-01-28 17:52:43Z wwalker $'
  10. __version__ = '$Revision: 4471 $'
  11. __date__ = '$Date: 2009-01-28 12:52:43 -0500 (Wed, 28 Jan 2009) $'
  12. __copyright__ = 'Copyright (c) 2005-2008 Sun Microsystems Inc.'
  13. __license__ = 'LGPL'
  14. import pyatspi
  15. import debug
  16. import orca_state
  17. import rolenames
  18. import settings
  19. from orca_i18n import _
  20. from orca_i18n import ngettext
  21. from orca_i18n import C_
  22.  
  23. class SpeechGenerator:
  24.     '''Takes accessible objects and produces a string to speak for
  25.     those objects.  See the getSpeech method, which is the primary
  26.     entry point.  Subclasses can feel free to override/extend the
  27.     speechGenerators instance field as they see fit.'''
  28.     
  29.     def __init__(self, script):
  30.         self._script = script
  31.         self.speechGenerators = { }
  32.         self.speechGenerators[pyatspi.ROLE_ALERT] = self._getSpeechForAlert
  33.         self.speechGenerators[pyatspi.ROLE_ANIMATION] = self._getSpeechForAnimation
  34.         self.speechGenerators[pyatspi.ROLE_ARROW] = self._getSpeechForArrow
  35.         self.speechGenerators[pyatspi.ROLE_CHECK_BOX] = self._getSpeechForCheckBox
  36.         self.speechGenerators[pyatspi.ROLE_CHECK_MENU_ITEM] = self._getSpeechForCheckMenuItem
  37.         self.speechGenerators[pyatspi.ROLE_COLUMN_HEADER] = self._getSpeechForColumnHeader
  38.         self.speechGenerators[pyatspi.ROLE_COMBO_BOX] = self._getSpeechForComboBox
  39.         self.speechGenerators[pyatspi.ROLE_DESKTOP_ICON] = self._getSpeechForDesktopIcon
  40.         self.speechGenerators[pyatspi.ROLE_DIAL] = self._getSpeechForDial
  41.         self.speechGenerators[pyatspi.ROLE_DIALOG] = self._getSpeechForDialog
  42.         self.speechGenerators[pyatspi.ROLE_DIRECTORY_PANE] = self._getSpeechForDirectoryPane
  43.         self.speechGenerators[pyatspi.ROLE_EMBEDDED] = self._getSpeechForEmbedded
  44.         self.speechGenerators[pyatspi.ROLE_FRAME] = self._getSpeechForFrame
  45.         self.speechGenerators[pyatspi.ROLE_HTML_CONTAINER] = self._getSpeechForHtmlContainer
  46.         self.speechGenerators[pyatspi.ROLE_ICON] = self._getSpeechForIcon
  47.         self.speechGenerators[pyatspi.ROLE_IMAGE] = self._getSpeechForImage
  48.         self.speechGenerators[pyatspi.ROLE_LABEL] = self._getSpeechForLabel
  49.         self.speechGenerators[pyatspi.ROLE_LAYERED_PANE] = self._getSpeechForLayeredPane
  50.         self.speechGenerators[pyatspi.ROLE_LIST] = self._getSpeechForList
  51.         self.speechGenerators[pyatspi.ROLE_LIST_ITEM] = self._getSpeechForListItem
  52.         self.speechGenerators[pyatspi.ROLE_MENU] = self._getSpeechForMenu
  53.         self.speechGenerators[pyatspi.ROLE_MENU_BAR] = self._getSpeechForMenuBar
  54.         self.speechGenerators[pyatspi.ROLE_MENU_ITEM] = self._getSpeechForMenuItem
  55.         self.speechGenerators[pyatspi.ROLE_OPTION_PANE] = self._getSpeechForOptionPane
  56.         self.speechGenerators[pyatspi.ROLE_PAGE_TAB] = self._getSpeechForPageTab
  57.         self.speechGenerators[pyatspi.ROLE_PAGE_TAB_LIST] = self._getSpeechForPageTabList
  58.         self.speechGenerators[pyatspi.ROLE_PARAGRAPH] = self._getSpeechForText
  59.         self.speechGenerators[pyatspi.ROLE_PASSWORD_TEXT] = self._getSpeechForText
  60.         self.speechGenerators[pyatspi.ROLE_PROGRESS_BAR] = self._getSpeechForProgressBar
  61.         self.speechGenerators[pyatspi.ROLE_PUSH_BUTTON] = self._getSpeechForPushButton
  62.         self.speechGenerators[pyatspi.ROLE_RADIO_BUTTON] = self._getSpeechForRadioButton
  63.         self.speechGenerators[pyatspi.ROLE_RADIO_MENU_ITEM] = self._getSpeechForRadioMenuItem
  64.         self.speechGenerators[pyatspi.ROLE_ROW_HEADER] = self._getSpeechForRowHeader
  65.         self.speechGenerators[pyatspi.ROLE_SCROLL_BAR] = self._getSpeechForScrollBar
  66.         self.speechGenerators[pyatspi.ROLE_SLIDER] = self._getSpeechForSlider
  67.         self.speechGenerators[pyatspi.ROLE_SPIN_BUTTON] = self._getSpeechForSpinButton
  68.         self.speechGenerators[pyatspi.ROLE_SPLIT_PANE] = self._getSpeechForSplitPane
  69.         self.speechGenerators[pyatspi.ROLE_TABLE] = self._getSpeechForTable
  70.         self.speechGenerators[pyatspi.ROLE_TABLE_CELL] = self._getSpeechForTableCellRow
  71.         self.speechGenerators[pyatspi.ROLE_TABLE_COLUMN_HEADER] = self._getSpeechForTableColumnHeader
  72.         self.speechGenerators[pyatspi.ROLE_TABLE_ROW_HEADER] = self._getSpeechForTableRowHeader
  73.         self.speechGenerators[pyatspi.ROLE_TEAROFF_MENU_ITEM] = self._getSpeechForMenu
  74.         self.speechGenerators[pyatspi.ROLE_TERMINAL] = self._getSpeechForTerminal
  75.         self.speechGenerators[pyatspi.ROLE_TEXT] = self._getSpeechForText
  76.         self.speechGenerators[pyatspi.ROLE_TOGGLE_BUTTON] = self._getSpeechForToggleButton
  77.         self.speechGenerators[pyatspi.ROLE_TOOL_BAR] = self._getSpeechForToolBar
  78.         self.speechGenerators[pyatspi.ROLE_TREE] = self._getSpeechForTable
  79.         self.speechGenerators[pyatspi.ROLE_TREE_TABLE] = self._getSpeechForTable
  80.         self.speechGenerators[pyatspi.ROLE_WINDOW] = self._getSpeechForWindow
  81.  
  82.     
  83.     def _addSpeechForObjectAccelerator(self, obj, utterances):
  84.         '''Adds an utterance that describes the keyboard accelerator for the
  85.         given object to the list of utterances passed in.
  86.  
  87.         Arguments:
  88.         - obj: the Accessible object
  89.         - utterances: the list of utterances to add to.
  90.  
  91.         Returns a list of utterances to be spoken.
  92.         '''
  93.         if settings.speechVerbosityLevel == settings.VERBOSITY_LEVEL_VERBOSE:
  94.             (mnemonic, shortcut, accelerator) = self._script.getKeyBinding(obj)
  95.             if accelerator:
  96.                 utterances.append(accelerator)
  97.             
  98.         
  99.  
  100.     
  101.     def _addSpeechForObjectMnemonic(self, obj, utterances):
  102.         '''Adds an utterance that describes the mnemonic for the given object
  103.         to the utterances passed in.
  104.  
  105.         Arguments:
  106.         - obj: the Accessible object
  107.         - utterances: the list of utterances to add to.
  108.         '''
  109.         if settings.enableMnemonicSpeaking:
  110.             (mnemonic, shortcut, accelerator) = self._script.getKeyBinding(obj)
  111.             if mnemonic:
  112.                 mnemonic = mnemonic[-1]
  113.             
  114.             if not mnemonic and shortcut:
  115.                 mnemonic = shortcut
  116.             
  117.             if mnemonic:
  118.                 utterances.append(mnemonic)
  119.             
  120.         
  121.  
  122.     
  123.     def _getSpeechForObjectAvailability(self, obj):
  124.         '''Returns a list of utterances that describes the availability
  125.         of the given object.
  126.  
  127.         Arguments:
  128.         - obj: the Accessible object
  129.  
  130.         Returns a list of utterances to be spoken.
  131.         '''
  132.         state = obj.getState()
  133.         if not state.contains(pyatspi.STATE_SENSITIVE):
  134.             return [
  135.                 _('grayed')]
  136.         return []
  137.  
  138.     
  139.     def _getSpeechForObjectLabel(self, obj):
  140.         label = self._script.getDisplayedLabel(obj)
  141.         if label:
  142.             return [
  143.                 label]
  144.         return []
  145.  
  146.     
  147.     def _getSpeechForObjectName(self, obj):
  148.         name = self._script.getDisplayedText(obj)
  149.         if name:
  150.             return [
  151.                 name]
  152.         if obj.description:
  153.             return [
  154.                 obj.description]
  155.         return []
  156.  
  157.     
  158.     def getSpeechForObjectRole(self, obj, role = None):
  159.         if obj.getRole() != pyatspi.ROLE_UNKNOWN:
  160.             return [
  161.                 rolenames.getSpeechForRoleName(obj, role)]
  162.         return []
  163.  
  164.     
  165.     def _getSpeechForAllTextSelection(self, obj):
  166.         """Check if this object has text associated with it and it's 
  167.         completely selected.
  168.  
  169.         Arguments:
  170.         - obj: the object being presented
  171.         """
  172.         utterance = []
  173.         
  174.         try:
  175.             textObj = obj.queryText()
  176.         except:
  177.             pass
  178.  
  179.         noOfSelections = textObj.getNSelections()
  180.         if noOfSelections == 1:
  181.             (string, startOffset, endOffset) = textObj.getTextAtOffset(0, pyatspi.TEXT_BOUNDARY_LINE_START)
  182.             if startOffset == 0 and endOffset == len(string):
  183.                 utterance = [
  184.                     C_('text', 'selected')]
  185.             
  186.         
  187.         return utterance
  188.  
  189.     
  190.     def _getSpeechForRequiredObject(self, obj):
  191.         '''Returns the list of utterances that describe the required state
  192.         of the given object.
  193.  
  194.         Arguments:
  195.         - obj: the Accessible object
  196.  
  197.         Returns a list of utterances to be spoken.
  198.         '''
  199.         if not settings.presentRequiredState:
  200.             return []
  201.         state = obj.getState()
  202.         if state.contains(pyatspi.STATE_REQUIRED):
  203.             return [
  204.                 settings.speechRequiredStateString]
  205.         return []
  206.  
  207.     
  208.     def _debugGenerator(self, generatorName, obj, already_focused, utterances):
  209.         '''Prints debug.LEVEL_FINER information regarding the speech generator.
  210.  
  211.         Arguments:
  212.         - generatorName: the name of the generator
  213.         - obj: the object being presented
  214.         - already_focused: False if object just received focus
  215.         - utterances: the generated text
  216.         '''
  217.         debug.println(debug.LEVEL_FINER, 'GENERATOR: %s' % generatorName)
  218.         debug.println(debug.LEVEL_FINER, '           obj             = %s' % obj.name)
  219.         debug.println(debug.LEVEL_FINER, '           role            = %s' % obj.getRoleName())
  220.         debug.println(debug.LEVEL_FINER, '           already_focused = %s' % already_focused)
  221.         debug.println(debug.LEVEL_FINER, '           utterances:')
  222.         for text in utterances:
  223.             debug.println(debug.LEVEL_FINER, '               (%s)' % text)
  224.         
  225.  
  226.     
  227.     def _getDefaultSpeech(self, obj, already_focused, role = None):
  228.         """Gets a list of utterances to be spoken for the current
  229.         object's name, role, and any accelerators.  This is usually the
  230.         fallback speech generator should no other specialized speech
  231.         generator exist for this object.
  232.  
  233.         The default speech will be of the following form:
  234.  
  235.         label name role availability mnemonic
  236.  
  237.         Arguments:
  238.         - obj: an Accessible
  239.         - already_focused: False if object just received focus
  240.         - role: A role that should be used instead of the Accessible's 
  241.           possible role.
  242.  
  243.         Returns a list of utterances to be spoken for the object.
  244.         """
  245.         utterances = []
  246.         if not already_focused:
  247.             label = self._getSpeechForObjectLabel(obj)
  248.             utterances.extend(label)
  249.             name = self._getSpeechForObjectName(obj)
  250.             if name != label:
  251.                 utterances.extend(name)
  252.             
  253.             utterances.extend(self._getSpeechForAllTextSelection(obj))
  254.             utterances.extend(self.getSpeechForObjectRole(obj, role))
  255.             utterances.extend(self._getSpeechForObjectAvailability(obj))
  256.             if obj == orca_state.locusOfFocus:
  257.                 self._addSpeechForObjectMnemonic(obj, utterances)
  258.             
  259.         
  260.         self._debugGenerator('_getDefaultSpeech', obj, already_focused, utterances)
  261.         return utterances
  262.  
  263.     
  264.     def _getSpeechForAlert(self, obj, already_focused):
  265.         '''Gets the title of the dialog and the contents of labels inside the
  266.         dialog that are not associated with any other objects.
  267.  
  268.         Arguments:
  269.         - obj: the Accessible dialog
  270.         - already_focused: False if object just received focus
  271.  
  272.         Returns a list of utterances be spoken.
  273.         '''
  274.         utterances = []
  275.         label = self._getSpeechForObjectLabel(obj)
  276.         utterances.extend(label)
  277.         name = self._getSpeechForObjectName(obj)
  278.         if name != label:
  279.             utterances.extend(name)
  280.         
  281.         labels = self._script.findUnrelatedLabels(obj)
  282.         for label in labels:
  283.             name = self._getSpeechForObjectName(label)
  284.             utterances.extend(name)
  285.         
  286.         self._debugGenerator('_getSpeechForAlert', obj, already_focused, utterances)
  287.         return utterances
  288.  
  289.     
  290.     def _getSpeechForAnimation(self, obj, already_focused):
  291.         '''Gets the speech for an animation.
  292.  
  293.         Arguments:
  294.         - obj: the animation
  295.         - already_focused: False if object just received focus
  296.  
  297.         Returns a list of utterances to be spoken.
  298.         '''
  299.         utterances = []
  300.         label = self._getSpeechForObjectLabel(obj)
  301.         utterances.extend(label)
  302.         name = self._getSpeechForObjectName(obj)
  303.         if name != label:
  304.             utterances.extend(name)
  305.         
  306.         self._debugGenerator('_getSpeechForAnimation', obj, already_focused, utterances)
  307.         return utterances
  308.  
  309.     
  310.     def _getSpeechForArrow(self, obj, already_focused):
  311.         '''Gets a list of utterances to be spoken for an arrow.
  312.  
  313.         Arguments:
  314.         - obj: the arrow
  315.         - already_focused: False if object just received focus
  316.  
  317.         Returns a list of utterances to be spoken for the object.
  318.         '''
  319.         utterances = self._getDefaultSpeech(obj, already_focused)
  320.         self._debugGenerator('_getSpeechForArrow', obj, already_focused, utterances)
  321.         return utterances
  322.  
  323.     
  324.     def _getSpeechForCheckBox(self, obj, already_focused):
  325.         '''Get the speech for a check box.  If the check box already had
  326.         focus, then only the state is spoken.
  327.  
  328.         Arguments:
  329.         - obj: the check box
  330.         - already_focused: False if object just received focus
  331.  
  332.         Returns a list of utterances to be spoken for the object.
  333.         '''
  334.         utterances = []
  335.         state = obj.getState()
  336.         if state.contains(pyatspi.STATE_INDETERMINATE):
  337.             checkedState = _('partially checked')
  338.         elif state.contains(pyatspi.STATE_CHECKED):
  339.             checkedState = _('checked')
  340.         else:
  341.             checkedState = _('not checked')
  342.         if not already_focused:
  343.             label = self._getSpeechForObjectLabel(obj)
  344.             utterances.extend(label)
  345.             name = self._getSpeechForObjectName(obj)
  346.             if name != label:
  347.                 utterances.extend(name)
  348.             
  349.             if obj.getRole() == pyatspi.ROLE_TABLE_CELL:
  350.                 utterances.extend(self.getSpeechForObjectRole(obj, pyatspi.ROLE_CHECK_BOX))
  351.             else:
  352.                 utterances.extend(self.getSpeechForObjectRole(obj))
  353.             utterances.append(checkedState)
  354.             utterances.extend(self._getSpeechForRequiredObject(obj))
  355.             utterances.extend(self._getSpeechForObjectAvailability(obj))
  356.             self._addSpeechForObjectMnemonic(obj, utterances)
  357.         else:
  358.             utterances.append(checkedState)
  359.         self._debugGenerator('_getSpeechForCheckBox', obj, already_focused, utterances)
  360.         return utterances
  361.  
  362.     
  363.     def _getSpeechForCheckMenuItem(self, obj, already_focused):
  364.         '''Get the speech for a check menu item.  If the check menu item
  365.         already had focus, then only the state is spoken.
  366.  
  367.         Arguments:
  368.         - obj: the check menu item
  369.         - already_focused: False if object just received focus
  370.  
  371.         Returns a list of utterances to be spoken for the object.
  372.         '''
  373.         utterances = self._getSpeechForCheckBox(obj, already_focused)
  374.         if not already_focused:
  375.             self._addSpeechForObjectAccelerator(obj, utterances)
  376.         
  377.         self._debugGenerator('_getSpeechForCheckMenuItem', obj, already_focused, utterances)
  378.         return utterances
  379.  
  380.     
  381.     def _getSpeechForColumnHeader(self, obj, already_focused):
  382.         '''Get the speech for a column header.
  383.  
  384.         Arguments:
  385.         - obj: the column header
  386.         - already_focused: False if object just received focus
  387.  
  388.         Returns a list of utterances to be spoken for the object.
  389.         '''
  390.         utterances = self._getDefaultSpeech(obj, already_focused)
  391.         self._debugGenerator('_getSpeechForColumnHeader', obj, already_focused, utterances)
  392.         return utterances
  393.  
  394.     
  395.     def _getSpeechForComboBox(self, obj, already_focused):
  396.         '''Get the speech for a combo box.  If the combo box already has focus,
  397.         then only the selection is spoken.
  398.  
  399.         Arguments:
  400.         - obj: the combo box
  401.         - already_focused: False if object just received focus
  402.  
  403.         Returns a list of utterances to be spoken for the object.
  404.         '''
  405.         utterances = []
  406.         if not already_focused:
  407.             label = self._getSpeechForObjectLabel(obj)
  408.             utterances.extend(label)
  409.         else:
  410.             label = None
  411.         name = self._getSpeechForObjectName(obj)
  412.         if name != label:
  413.             utterances.extend(name)
  414.         
  415.         if not already_focused:
  416.             utterances.extend(self.getSpeechForObjectRole(obj))
  417.         
  418.         for child in obj:
  419.             if child.getRole() == pyatspi.ROLE_TEXT:
  420.                 utterances.extend(self._getSpeechForAllTextSelection(child))
  421.                 continue
  422.         
  423.         utterances.extend(self._getSpeechForObjectAvailability(obj))
  424.         self._addSpeechForObjectMnemonic(obj, utterances)
  425.         self._debugGenerator('_getSpeechForComboBox', obj, already_focused, utterances)
  426.         return utterances
  427.  
  428.     
  429.     def _getSpeechForDesktopIcon(self, obj, already_focused):
  430.         '''Get the speech for a desktop icon.
  431.  
  432.         Arguments:
  433.         - obj: the desktop icon
  434.         - already_focused: False if object just received focus
  435.  
  436.         Returns a list of utterances to be spoken for the object.
  437.         '''
  438.         utterances = self._getDefaultSpeech(obj, already_focused)
  439.         self._debugGenerator('_getSpeechForDesktopIcon', obj, already_focused, utterances)
  440.         return utterances
  441.  
  442.     
  443.     def _getSpeechForDial(self, obj, already_focused):
  444.         '''Get the speech for a dial.
  445.  
  446.         Arguments:
  447.         - obj: the dial
  448.         - already_focused: False if object just received focus
  449.  
  450.         Returns a list of utterances to be spoken for the object.
  451.         '''
  452.         utterances = self._getDefaultSpeech(obj, already_focused)
  453.         self._debugGenerator('_getSpeechForDial', obj, already_focused, utterances)
  454.         return utterances
  455.  
  456.     
  457.     def _getSpeechForDialog(self, obj, already_focused):
  458.         '''Get the speech for a dialog box.
  459.  
  460.         Arguments:
  461.         - obj: the dialog box
  462.         - already_focused: False if object just received focus
  463.  
  464.         Returns a list of utterances to be spoken for the object.
  465.         '''
  466.         utterances = self._getSpeechForAlert(obj, already_focused)
  467.         self._debugGenerator('_getSpeechForDialog', obj, already_focused, utterances)
  468.         return utterances
  469.  
  470.     
  471.     def _getSpeechForDirectoryPane(self, obj, already_focused):
  472.         '''Get the speech for a directory pane.
  473.  
  474.         Arguments:
  475.         - obj: the dial
  476.         - already_focused: False if object just received focus
  477.  
  478.         Returns a list of utterances to be spoken for the object.
  479.         '''
  480.         utterances = self._getDefaultSpeech(obj, already_focused)
  481.         self._debugGenerator('_getSpeechForDirectoryPane', obj, already_focused, utterances)
  482.         return utterances
  483.  
  484.     
  485.     def _getSpeechForEmbedded(self, obj, already_focused, role = None):
  486.         """Gets a list of utterances to be spoken for the current
  487.         embedded component (i.e., something in a panel).
  488.  
  489.         Arguments:
  490.         - obj: an Accessible
  491.         - already_focused: False if object just received focus
  492.         - role: A role that should be used instead of the Accessible's 
  493.           possible role.
  494.  
  495.         Returns a list of utterances to be spoken for the object.
  496.         """
  497.         utterances = []
  498.         label = self._getSpeechForObjectLabel(obj)
  499.         utterances.extend(label)
  500.         name = self._getSpeechForObjectName(obj)
  501.         if name != label:
  502.             utterances.extend(name)
  503.         
  504.         if not utterances:
  505.             
  506.             try:
  507.                 utterances.append(obj.getApplication().name)
  508.  
  509.         
  510.         self._debugGenerator('_getSpeechForEmbedded', obj, already_focused, utterances)
  511.         return utterances
  512.  
  513.     
  514.     def _getSpeechForFrame(self, obj, already_focused):
  515.         '''Get the speech for a frame.
  516.  
  517.         Arguments:
  518.         - obj: the frame
  519.         - already_focused: False if object just received focus
  520.  
  521.         Returns a list of utterances to be spoken for the object.
  522.         '''
  523.         utterances = []
  524.         if not already_focused:
  525.             label = self._getSpeechForObjectLabel(obj)
  526.             utterances.extend(label)
  527.             name = self._getSpeechForObjectName(obj)
  528.             if name != label:
  529.                 utterances.extend(name)
  530.             
  531.             utterances.extend(self._getSpeechForAllTextSelection(obj))
  532.             utterances.extend(self.getSpeechForObjectRole(obj))
  533.             alertAndDialogCount = self._script.getUnfocusedAlertAndDialogCount(obj)
  534.             if alertAndDialogCount > 0:
  535.                 line = ngettext('%d unfocused dialog', '%d unfocused dialogs', alertAndDialogCount) % alertAndDialogCount
  536.                 utterances.append(line)
  537.             
  538.             utterances.extend(self._getSpeechForObjectAvailability(obj))
  539.         
  540.         self._debugGenerator('_getSpeechForFrame', obj, already_focused, utterances)
  541.         return utterances
  542.  
  543.     
  544.     def _getSpeechForHtmlContainer(self, obj, already_focused):
  545.         '''Get the speech for an HTML container.
  546.  
  547.         Arguments:
  548.         - obj: the dial
  549.         - already_focused: False if object just received focus
  550.  
  551.         Returns a list of utterances to be spoken for the object.
  552.         '''
  553.         utterances = self._getDefaultSpeech(obj, already_focused)
  554.         self._debugGenerator('_getSpeechForHtmlContainer', obj, already_focused, utterances)
  555.         return utterances
  556.  
  557.     
  558.     def _getSpeechForIcon(self, obj, already_focused):
  559.         '''Get the speech for an icon.
  560.  
  561.         Arguments:
  562.         - obj: the icon
  563.         - already_focused: False if object just received focus
  564.  
  565.         Returns a list of utterances to be spoken for the object.
  566.         '''
  567.         utterances = []
  568.         label = self._getSpeechForObjectLabel(obj)
  569.         utterances.extend(label)
  570.         name = self._getSpeechForObjectName(obj)
  571.         if name != label:
  572.             utterances.extend(name)
  573.         
  574.         
  575.         try:
  576.             image = obj.queryImage()
  577.         except NotImplementedError:
  578.             pass
  579.  
  580.         description = image.imageDescription
  581.         if description and len(description):
  582.             utterances.append(description)
  583.         
  584.         if settings.speechVerbosityLevel == settings.VERBOSITY_LEVEL_VERBOSE:
  585.             utterances.append(rolenames.getSpeechForRoleName(obj, pyatspi.ROLE_ICON))
  586.         
  587.         self._debugGenerator('_getSpeechForIcon', obj, already_focused, utterances)
  588.         return utterances
  589.  
  590.     
  591.     def _getSpeechForImage(self, obj, already_focused):
  592.         '''Get the speech for an image.
  593.  
  594.         Arguments:
  595.         - obj: the image
  596.         - already_focused: False if object just received focus
  597.  
  598.         Returns a list of utterances to be spoken for the object.
  599.         '''
  600.         utterances = self._getDefaultSpeech(obj, already_focused, pyatspi.ROLE_IMAGE)
  601.         self._debugGenerator('_getSpeechForImage', obj, already_focused, utterances)
  602.         return utterances
  603.  
  604.     
  605.     def _getSpeechForLabel(self, obj, already_focused):
  606.         '''Get the speech for a label.
  607.  
  608.         Arguments:
  609.         - obj: the label
  610.         - already_focused: False if object just received focus
  611.  
  612.         Returns a list of utterances to be spoken for the object.
  613.         '''
  614.         utterances = self._getDefaultSpeech(obj, already_focused)
  615.         self._debugGenerator('_getSpeechForLabel', obj, already_focused, utterances)
  616.         return utterances
  617.  
  618.     
  619.     def _getSpeechForLayeredPane(self, obj, already_focused):
  620.         '''Get the speech for a layered pane
  621.  
  622.         Arguments:
  623.         - obj: the table
  624.         - already_focused: False if object just received focus
  625.  
  626.         Returns a list of utterances to be spoken for the object.
  627.         '''
  628.         utterances = self._getDefaultSpeech(obj, already_focused)
  629.         self._debugGenerator('_getSpeechForLayeredPane', obj, already_focused, utterances)
  630.         hasItems = False
  631.         for child in obj:
  632.             state = child.getState()
  633.             if state.contains(pyatspi.STATE_SHOWING):
  634.                 hasItems = True
  635.                 break
  636.                 continue
  637.         
  638.         if not hasItems:
  639.             utterances.append(_('0 items'))
  640.         
  641.         return utterances
  642.  
  643.     
  644.     def _getSpeechForList(self, obj, already_focused):
  645.         '''Get the speech for a list.
  646.  
  647.         Arguments:
  648.         - obj: the list
  649.         - already_focused: False if object just received focus
  650.  
  651.         Returns a list of utterances to be spoken for the object.
  652.         '''
  653.         utterances = self._getDefaultSpeech(obj, already_focused)
  654.         self._debugGenerator('_getSpeechForList', obj, already_focused, utterances)
  655.         return utterances
  656.  
  657.     
  658.     def _getSpeechForListItem(self, obj, already_focused):
  659.         '''Get the speech for a listitem.
  660.  
  661.         Arguments:
  662.         - obj: the listitem
  663.         - already_focused: False if object just received focus
  664.  
  665.         Returns a list of utterances to be spoken for the object.
  666.         '''
  667.         utterances = []
  668.         if not already_focused:
  669.             label = self._getSpeechForObjectLabel(obj)
  670.             utterances.extend(label)
  671.             name = self._getSpeechForObjectName(obj)
  672.             if name != label:
  673.                 utterances.extend(name)
  674.             
  675.             utterances.extend(self._getSpeechForAllTextSelection(obj))
  676.         
  677.         state = obj.getState()
  678.         if state.contains(pyatspi.STATE_EXPANDABLE):
  679.             if state.contains(pyatspi.STATE_EXPANDED):
  680.                 utterances.append(_('expanded'))
  681.             else:
  682.                 utterances.append(_('collapsed'))
  683.         
  684.         utterances.extend(self._getSpeechForObjectAvailability(obj))
  685.         self._debugGenerator('_getSpeechForListItem', obj, already_focused, utterances)
  686.         return utterances
  687.  
  688.     
  689.     def _getSpeechForMenu(self, obj, already_focused):
  690.         '''Get the speech for a menu.
  691.  
  692.         Arguments:
  693.         - obj: the menu
  694.         - already_focused: False if object just received focus
  695.  
  696.         Returns a list of utterances to be spoken for the object.
  697.         '''
  698.         utterances = []
  699.         if not already_focused:
  700.             label = self._getSpeechForObjectLabel(obj)
  701.             utterances.extend(label)
  702.             name = self._getSpeechForObjectName(obj)
  703.             if name != label:
  704.                 utterances.extend(name)
  705.             
  706.             utterances.extend(self._getSpeechForAllTextSelection(obj))
  707.             utterances.extend(self.getSpeechForObjectRole(obj))
  708.             utterances.extend(self._getSpeechForObjectAvailability(obj))
  709.             self._addSpeechForObjectMnemonic(obj, utterances)
  710.             self._addSpeechForObjectAccelerator(obj, utterances)
  711.         
  712.         self._debugGenerator('_getSpeechForMenu', obj, already_focused, utterances)
  713.         return utterances
  714.  
  715.     
  716.     def _getSpeechForMenuBar(self, obj, already_focused):
  717.         '''Get the speech for a menu bar.
  718.  
  719.         Arguments:
  720.         - obj: the menu bar
  721.         - already_focused: False if object just received focus
  722.  
  723.         Returns a list of utterances to be spoken for the object.
  724.         '''
  725.         utterances = self._getDefaultSpeech(obj, already_focused)
  726.         self._debugGenerator('_getSpeechForMenuBar', obj, already_focused, utterances)
  727.         return utterances
  728.  
  729.     
  730.     def _getSpeechForMenuItem(self, obj, already_focused):
  731.         '''Get the speech for a menu item.
  732.  
  733.         Arguments:
  734.         - obj: the menu item
  735.         - already_focused: False if object just received focus
  736.  
  737.         Returns a list of utterances to be spoken for the object.
  738.         '''
  739.         utterances = []
  740.         label = self._getSpeechForObjectLabel(obj)
  741.         utterances.extend(label)
  742.         name = self._getSpeechForObjectName(obj)
  743.         if name != label:
  744.             utterances.extend(name)
  745.         
  746.         state = obj.getState()
  747.         if state.contains(pyatspi.STATE_CHECKED):
  748.             utterances.append(_('checked'))
  749.         
  750.         if not already_focused:
  751.             utterances.extend(self._getSpeechForObjectAvailability(obj))
  752.             self._addSpeechForObjectMnemonic(obj, utterances)
  753.             self._addSpeechForObjectAccelerator(obj, utterances)
  754.         
  755.         self._debugGenerator('_getSpeechForMenuItem', obj, already_focused, utterances)
  756.         return utterances
  757.  
  758.     
  759.     def _getSpeechForText(self, obj, already_focused):
  760.         '''Get the speech for a text component.
  761.  
  762.         Arguments:
  763.         - obj: the text component
  764.         - already_focused: False if object just received focus
  765.  
  766.         Returns a list of utterances to be spoken for the object.
  767.         '''
  768.         utterances = []
  769.         utterances.extend(self._getSpeechForObjectLabel(obj))
  770.         if len(utterances) == 0:
  771.             if obj.name and len(obj.name):
  772.                 utterances.append(obj.name)
  773.             
  774.         
  775.         if settings.presentReadOnlyText and self._script.isReadOnlyTextArea(obj):
  776.             utterances.append(settings.speechReadOnlyString)
  777.         
  778.         if obj.getRole() != pyatspi.ROLE_PARAGRAPH:
  779.             utterances.extend(self.getSpeechForObjectRole(obj))
  780.         
  781.         (text, caretOffset, startOffset) = self._script.getTextLineAtCaret(obj)
  782.         utterances.append(text)
  783.         utterances.extend(self._getSpeechForAllTextSelection(obj))
  784.         self._addSpeechForObjectMnemonic(obj, utterances)
  785.         self._debugGenerator('_getSpeechForText', obj, already_focused, utterances)
  786.         return utterances
  787.  
  788.     
  789.     def _getSpeechForOptionPane(self, obj, already_focused):
  790.         '''Get the speech for an option pane.
  791.  
  792.         Arguments:
  793.         - obj: the option pane
  794.         - already_focused: False if object just received focus
  795.  
  796.         Returns a list of utterances to be spoken for the object.
  797.         '''
  798.         utterances = self._getDefaultSpeech(obj, already_focused)
  799.         self._debugGenerator('_getSpeechForOptionPane', obj, already_focused, utterances)
  800.         return utterances
  801.  
  802.     
  803.     def _getSpeechForPageTab(self, obj, already_focused):
  804.         '''Get the speech for a page tab.
  805.  
  806.         Arguments:
  807.         - obj: the page tab
  808.         - already_focused: False if object just received focus
  809.  
  810.         Returns a list of utterances to be spoken for the object.
  811.         '''
  812.         utterances = self._getDefaultSpeech(obj, already_focused)
  813.         self._debugGenerator('_getSpeechForPageTab', obj, already_focused, utterances)
  814.         return utterances
  815.  
  816.     
  817.     def _getSpeechForPageTabList(self, obj, already_focused):
  818.         '''Get the speech for a page tab list.
  819.  
  820.         Arguments:
  821.         - obj: the page tab list
  822.         - already_focused: False if object just received focus
  823.  
  824.         Returns a list of utterances to be spoken for the object.
  825.         '''
  826.         utterances = self._getDefaultSpeech(obj, already_focused)
  827.         self._debugGenerator('_getSpeechForPageTabList', obj, already_focused, utterances)
  828.         return utterances
  829.  
  830.     
  831.     def _getSpeechForProgressBar(self, obj, already_focused):
  832.         '''Get the speech for a progress bar.  If the object already
  833.         had focus, just the new value is spoken.
  834.  
  835.         Arguments:
  836.         - obj: the progress bar
  837.         - already_focused: False if object just received focus
  838.  
  839.         Returns a list of utterances to be spoken for the object.
  840.         '''
  841.         value = obj.queryValue()
  842.         percentValue = (value.currentValue / (value.maximumValue - value.minimumValue)) * 100
  843.         percentage = _('%d percent.') % percentValue + ' '
  844.         utterances = []
  845.         if not already_focused:
  846.             label = self._getSpeechForObjectLabel(obj)
  847.             utterances.extend(label)
  848.             name = self._getSpeechForObjectName(obj)
  849.             if name != label:
  850.                 utterances.extend(name)
  851.             
  852.             utterances.extend(self.getSpeechForObjectRole(obj))
  853.         
  854.         utterances.append(percentage)
  855.         self._debugGenerator('_getSpeechForProgressBar', obj, already_focused, utterances)
  856.         return utterances
  857.  
  858.     
  859.     def _getSpeechForPushButton(self, obj, already_focused):
  860.         '''Get the speech for a push button
  861.  
  862.         Arguments:
  863.         - obj: the push button
  864.         - already_focused: False if object just received focus
  865.  
  866.         Returns a list of utterances to be spoken for the object.
  867.         '''
  868.         utterances = self._getDefaultSpeech(obj, already_focused)
  869.         self._debugGenerator('_getSpeechForPushButton', obj, already_focused, utterances)
  870.         return utterances
  871.  
  872.     
  873.     def _getSpeechForRadioButton(self, obj, already_focused):
  874.         '''Get the speech for a radio button.  If the button already had
  875.         focus, then only the state is spoken.
  876.  
  877.         Arguments:
  878.         - obj: the check box
  879.         - already_focused: False if object just received focus
  880.  
  881.         Returns a list of utterances to be spoken for the object.
  882.         '''
  883.         utterances = []
  884.         state = obj.getState()
  885.         if state.contains(pyatspi.STATE_CHECKED):
  886.             selectionState = C_('radiobutton', 'selected')
  887.         else:
  888.             selectionState = C_('radiobutton', 'not selected')
  889.         if not already_focused:
  890.             utterances.extend(self._getSpeechForObjectName(obj))
  891.             utterances.append(selectionState)
  892.             utterances.extend(self.getSpeechForObjectRole(obj))
  893.             utterances.extend(self._getSpeechForObjectAvailability(obj))
  894.             self._addSpeechForObjectMnemonic(obj, utterances)
  895.         else:
  896.             utterances.append(selectionState)
  897.         self._debugGenerator('_getSpeechForRadioButton', obj, already_focused, utterances)
  898.         return utterances
  899.  
  900.     
  901.     def _getSpeechForRadioMenuItem(self, obj, already_focused):
  902.         '''Get the speech for a radio menu item.  If the menu item
  903.         already had focus, then only the state is spoken.
  904.  
  905.         Arguments:
  906.         - obj: the radio menu item
  907.         - already_focused: False if object just received focus
  908.  
  909.         Returns a list of utterances to be spoken for the object.
  910.         '''
  911.         utterances = []
  912.         utterances.extend(self._getSpeechForRadioButton(obj, False))
  913.         if not already_focused:
  914.             self._addSpeechForObjectAccelerator(obj, utterances)
  915.         
  916.         self._debugGenerator('_getSpeechForRadioMenuItem', obj, already_focused, utterances)
  917.         return utterances
  918.  
  919.     
  920.     def _getSpeechForRowHeader(self, obj, already_focused):
  921.         '''Get the speech for a row header.
  922.  
  923.         Arguments:
  924.         - obj: the column header
  925.         - already_focused: False if object just received focus
  926.  
  927.         Returns a list of utterances to be spoken for the object.
  928.         '''
  929.         utterances = self._getDefaultSpeech(obj, already_focused)
  930.         self._debugGenerator('_getSpeechForRowHeader', obj, already_focused, utterances)
  931.         return utterances
  932.  
  933.     
  934.     def _getSpeechForScrollBar(self, obj, already_focused):
  935.         '''Get the speech for a scroll bar.
  936.  
  937.         Arguments:
  938.         - obj: the scroll bar
  939.         - already_focused: False if object just received focus
  940.  
  941.         Returns a list of utterances to be spoken for the object.
  942.         '''
  943.         utterances = self._getDefaultSpeech(obj, already_focused)
  944.         self._debugGenerator('_getSpeechForScrollBar', obj, already_focused, utterances)
  945.         return utterances
  946.  
  947.     
  948.     def _getSpeechForSlider(self, obj, already_focused):
  949.         '''Get the speech for a slider.  If the object already
  950.         had focus, just the value is spoken.
  951.  
  952.         Arguments:
  953.         - obj: the slider
  954.         - already_focused: False if object just received focus
  955.  
  956.         Returns a list of utterances to be spoken for the object.
  957.         '''
  958.         valueString = self._script.getTextForValue(obj)
  959.         if already_focused:
  960.             utterances = [
  961.                 valueString]
  962.         else:
  963.             utterances = []
  964.             utterances.extend(self._getSpeechForObjectLabel(obj))
  965.             if not utterances:
  966.                 utterances.extend(self._getSpeechForObjectName(obj))
  967.             
  968.             utterances.extend(self.getSpeechForObjectRole(obj))
  969.             utterances.append(valueString)
  970.             utterances.extend(self._getSpeechForRequiredObject(obj))
  971.             utterances.extend(self._getSpeechForObjectAvailability(obj))
  972.             self._addSpeechForObjectMnemonic(obj, utterances)
  973.         self._debugGenerator('_getSpeechForSlider', obj, already_focused, utterances)
  974.         return utterances
  975.  
  976.     
  977.     def _getSpeechForSpinButton(self, obj, already_focused):
  978.         '''Get the speech for a spin button.  If the object already has
  979.         focus, then only the new value is spoken.
  980.  
  981.         Arguments:
  982.         - obj: the spin button
  983.         - already_focused: False if object just received focus
  984.  
  985.         Returns a list of utterances to be spoken for the object.
  986.         '''
  987.         if already_focused:
  988.             utterances = [
  989.                 self._script.getDisplayedText(obj)]
  990.         else:
  991.             utterances = self._getDefaultSpeech(obj, already_focused)
  992.             utterances.extend(self._getSpeechForRequiredObject(obj))
  993.         self._debugGenerator('_getSpeechForSpinButton', obj, already_focused, utterances)
  994.         return utterances
  995.  
  996.     
  997.     def _getSpeechForSplitPane(self, obj, already_focused):
  998.         '''Get the speech for a split pane.
  999.  
  1000.         Arguments:
  1001.         - obj: the split pane
  1002.         - already_focused: False if object just received focus
  1003.  
  1004.         Returns a list of utterances to be spoken for the object.
  1005.         '''
  1006.         valueString = self._script.getTextForValue(obj)
  1007.         if already_focused:
  1008.             utterances = [
  1009.                 valueString]
  1010.         else:
  1011.             utterances = []
  1012.             utterances.extend(self._getSpeechForObjectLabel(obj))
  1013.             if not utterances:
  1014.                 utterances.extend(self._getSpeechForObjectName(obj))
  1015.             
  1016.             utterances.extend(self.getSpeechForObjectRole(obj))
  1017.             utterances.append(valueString)
  1018.             utterances.extend(self._getSpeechForObjectAvailability(obj))
  1019.             self._addSpeechForObjectMnemonic(obj, utterances)
  1020.         self._debugGenerator('_getSpeechForSplitPane', obj, already_focused, utterances)
  1021.         return utterances
  1022.  
  1023.     
  1024.     def _getSpeechForTable(self, obj, already_focused):
  1025.         '''Get the speech for a table
  1026.  
  1027.         Arguments:
  1028.         - obj: the table
  1029.         - already_focused: False if object just received focus
  1030.  
  1031.         Returns a list of utterances to be spoken for the object.
  1032.         '''
  1033.         utterances = self._getDefaultSpeech(obj, already_focused)
  1034.         self._debugGenerator('_getSpeechForTable', obj, already_focused, utterances)
  1035.         if not obj.childCount:
  1036.             utterances.append(_('0 items'))
  1037.         
  1038.         return utterances
  1039.  
  1040.     
  1041.     def _getSpeechForTableCell(self, obj, already_focused):
  1042.         '''Get the speech utterances for a single table cell
  1043.  
  1044.         Arguments:
  1045.         - obj: the table
  1046.         - already_focused: False if object just received focus
  1047.  
  1048.         Returns a list of utterances to be spoken for the object.
  1049.         '''
  1050.         utterances = []
  1051.         if obj.childCount == 2:
  1052.             cellOrder = []
  1053.             hasToggle = [
  1054.                 False,
  1055.                 False]
  1056.             for i, child in enumerate(obj):
  1057.                 
  1058.                 try:
  1059.                     action = child.queryAction()
  1060.                 except NotImplementedError:
  1061.                     continue
  1062.                     continue
  1063.  
  1064.                 for j in range(0, action.nActions):
  1065.                     if action.getName(j) in [
  1066.                         'toggle',
  1067.                         _('toggle')]:
  1068.                         hasToggle[i] = True
  1069.                         break
  1070.                         continue
  1071.                 
  1072.             
  1073.             if hasToggle[0] and not hasToggle[1]:
  1074.                 cellOrder = [
  1075.                     1,
  1076.                     0]
  1077.             elif not hasToggle[0] and hasToggle[1]:
  1078.                 cellOrder = [
  1079.                     0,
  1080.                     1]
  1081.             
  1082.             if cellOrder:
  1083.                 for i in cellOrder:
  1084.                     if already_focused and not hasToggle[i]:
  1085.                         continue
  1086.                     utterances.extend(self._getSpeechForTableCell(obj[i], already_focused))
  1087.                 
  1088.                 return utterances
  1089.         
  1090.         
  1091.         try:
  1092.             action = obj.queryAction()
  1093.         except NotImplementedError:
  1094.             action = None
  1095.  
  1096.         if action:
  1097.             for i in range(0, action.nActions):
  1098.                 debug.println(debug.LEVEL_FINEST, 'speechgenerator.__getTableCellUtterances ' + 'looking at action %d' % i)
  1099.                 if action.getName(i) in [
  1100.                     'toggle',
  1101.                     _('toggle')]:
  1102.                     utterances = self._getSpeechForCheckBox(obj, already_focused)
  1103.                     break
  1104.                     continue
  1105.             
  1106.         
  1107.         displayedText = self._script.getDisplayedText(self._script.getRealActiveDescendant(obj))
  1108.         if not already_focused and displayedText not in utterances:
  1109.             utterances.append(displayedText)
  1110.         
  1111.         
  1112.         try:
  1113.             image = obj.queryImage()
  1114.         except:
  1115.             image = None
  1116.  
  1117.         if (not displayedText or len(displayedText) == 0) and image:
  1118.             if not already_focused:
  1119.                 if image.imageDescription:
  1120.                     utterances.append(image.imageDescription)
  1121.                 
  1122.                 utterances.extend(self._getSpeechForImage(obj, already_focused))
  1123.             
  1124.         
  1125.         state = obj.getState()
  1126.         if state.contains(pyatspi.STATE_EXPANDABLE):
  1127.             if state.contains(pyatspi.STATE_EXPANDED):
  1128.                 utterances.append(_('expanded'))
  1129.                 childNodes = self._script.getChildNodes(obj)
  1130.                 children = len(childNodes)
  1131.                 if not children or settings.speechVerbosityLevel == settings.VERBOSITY_LEVEL_VERBOSE:
  1132.                     itemString = ngettext('%d item', '%d items', children) % children
  1133.                     utterances.append(itemString)
  1134.                 
  1135.             else:
  1136.                 utterances.append(_('collapsed'))
  1137.         
  1138.         utterances.extend(self._getSpeechForRequiredObject(obj))
  1139.         self._debugGenerator('_getSpeechForTableCell', obj, already_focused, utterances)
  1140.         return utterances
  1141.  
  1142.     
  1143.     def _getSpeechForTableCellRow(self, obj, already_focused):
  1144.         '''Get the speech for a table cell row or a single table cell
  1145.         if settings.readTableCellRow is False.
  1146.  
  1147.         Arguments:
  1148.         - obj: the table
  1149.         - already_focused: False if object just received focus
  1150.  
  1151.         Returns a list of utterances to be spoken for the object.
  1152.         '''
  1153.         utterances = []
  1154.         if not already_focused:
  1155.             
  1156.             try:
  1157.                 parent_table = obj.parent.queryTable()
  1158.             except NotImplementedError:
  1159.                 parent_table = None
  1160.  
  1161.             if settings.readTableCellRow and parent_table and not self._script.isLayoutOnly(obj.parent):
  1162.                 parent = obj.parent
  1163.                 index = self._script.getCellIndex(obj)
  1164.                 row = parent_table.getRowAtIndex(index)
  1165.                 column = parent_table.getColumnAtIndex(index)
  1166.                 speakAll = True
  1167.                 if 'lastRow' in self._script.pointOfReference and 'lastColumn' in self._script.pointOfReference:
  1168.                     pointOfReference = self._script.pointOfReference
  1169.                     if not pointOfReference['lastRow'] != row:
  1170.                         if row == 0 or row == parent_table.nRows - 1:
  1171.                             pass
  1172.                     speakAll = pointOfReference['lastColumn'] == column
  1173.                 
  1174.                 if speakAll:
  1175.                     for i in range(0, parent_table.nColumns):
  1176.                         cell = parent_table.getAccessibleAt(row, i)
  1177.                         if not cell:
  1178.                             debug.println(debug.LEVEL_WARNING, 'ERROR: speechgenerator.' + '_getSpeechForTableCellRow' + ' no accessible at (%d, %d)' % (row, i))
  1179.                             continue
  1180.                         
  1181.                         state = cell.getState()
  1182.                         showing = state.contains(pyatspi.STATE_SHOWING)
  1183.                         if showing:
  1184.                             label = self._script.getDisplayedText(self._script.getRealActiveDescendant(cell))
  1185.                             
  1186.                             try:
  1187.                                 action = cell.queryAction()
  1188.                             except NotImplementedError:
  1189.                                 action = None
  1190.  
  1191.                             if action:
  1192.                                 if label == None or len(label) == 0:
  1193.                                     for j in range(0, action.nActions):
  1194.                                         if action.getName(j) in [
  1195.                                             'toggle',
  1196.                                             _('toggle')]:
  1197.                                             accHeader = parent_table.getColumnHeader(i)
  1198.                                             utterances.append(accHeader.name)
  1199.                                             continue
  1200.                                     
  1201.                                 
  1202.                             utterances.extend(self._getSpeechForTableCell(cell, already_focused))
  1203.                             continue
  1204.                     
  1205.                 else:
  1206.                     utterances.extend(self._getSpeechForTableCell(obj, already_focused))
  1207.             else:
  1208.                 utterances = self._getSpeechForTableCell(obj, already_focused)
  1209.         else:
  1210.             utterances = self._getSpeechForTableCell(obj, already_focused)
  1211.         self._debugGenerator('_getSpeechForTableCellRow', obj, already_focused, utterances)
  1212.         return utterances
  1213.  
  1214.     
  1215.     def _getSpeechForTableColumnHeader(self, obj, already_focused):
  1216.         '''Get the speech for a table column header
  1217.  
  1218.         Arguments:
  1219.         - obj: the table column header
  1220.         - already_focused: False if object just received focus
  1221.  
  1222.         Returns a list of utterances to be spoken for the object.
  1223.         '''
  1224.         utterances = self._getSpeechForColumnHeader(obj, already_focused)
  1225.         self._debugGenerator('_getSpeechForTableColumnHeader', obj, already_focused, utterances)
  1226.         return utterances
  1227.  
  1228.     
  1229.     def _getSpeechForTableRowHeader(self, obj, already_focused):
  1230.         '''Get the speech for a table row header
  1231.  
  1232.         Arguments:
  1233.         - obj: the table row header
  1234.         - already_focused: False if object just received focus
  1235.  
  1236.         Returns a list of utterances to be spoken for the object.
  1237.         '''
  1238.         utterances = self._getSpeechForRowHeader(obj, already_focused)
  1239.         self._debugGenerator('_getSpeechForTableRowHeader', obj, already_focused, utterances)
  1240.         return utterances
  1241.  
  1242.     
  1243.     def _getSpeechForTearOffMenuItem(self, obj, already_focused):
  1244.         '''Get the speech for a tear off menu item
  1245.  
  1246.         Arguments:
  1247.         - obj: the tear off menu item
  1248.         - already_focused: False if object just received focus
  1249.  
  1250.         Returns a list of utterances to be spoken for the object.
  1251.         '''
  1252.         if settings.speechVerbosityLevel == settings.VERBOSITY_LEVEL_VERBOSE:
  1253.             utterances = [
  1254.                 rolenames.getSpeechForRoleName(obj)]
  1255.         else:
  1256.             utterances = [
  1257.                 _('tear off')]
  1258.         self._debugGenerator('_getSpeechForTearOffMenuItem', obj, already_focused, utterances)
  1259.         return utterances
  1260.  
  1261.     
  1262.     def _getSpeechForTerminal(self, obj, already_focused):
  1263.         '''Get the speech for a terminal
  1264.  
  1265.         Arguments:
  1266.         - obj: the terminal
  1267.         - already_focused: False if object just received focus
  1268.  
  1269.         Returns a list of utterances to be spoken for the object.
  1270.         '''
  1271.         title = None
  1272.         frame = self._script.getFrame(obj)
  1273.         if frame:
  1274.             title = frame.name
  1275.         
  1276.         if not title:
  1277.             title = self._script.getDisplayedLabel(obj)
  1278.         
  1279.         utterances = [
  1280.             title]
  1281.         self._debugGenerator('_getSpeechForTerminal', obj, already_focused, utterances)
  1282.         return utterances
  1283.  
  1284.     
  1285.     def _getSpeechForToggleButton(self, obj, already_focused):
  1286.         '''Get the speech for a toggle button.  If the toggle button already
  1287.         had focus, then only the state is spoken.
  1288.  
  1289.         Arguments:
  1290.         - obj: the check box
  1291.         - already_focused: False if object just received focus
  1292.  
  1293.         Returns a list of utterances to be spoken for the object.
  1294.         '''
  1295.         utterances = []
  1296.         state = obj.getState()
  1297.         if state.contains(pyatspi.STATE_CHECKED) or state.contains(pyatspi.STATE_PRESSED):
  1298.             checkedState = _('pressed')
  1299.         else:
  1300.             checkedState = _('not pressed')
  1301.         if not already_focused:
  1302.             label = self._getSpeechForObjectLabel(obj)
  1303.             utterances.extend(label)
  1304.             name = self._getSpeechForObjectName(obj)
  1305.             if name != label:
  1306.                 utterances.extend(name)
  1307.             
  1308.             utterances.extend(self.getSpeechForObjectRole(obj))
  1309.             utterances.append(checkedState)
  1310.             utterances.extend(self._getSpeechForObjectAvailability(obj))
  1311.             self._addSpeechForObjectMnemonic(obj, utterances)
  1312.         else:
  1313.             utterances.append(checkedState)
  1314.         self._debugGenerator('_getSpeechForToggleButton', obj, already_focused, utterances)
  1315.         return utterances
  1316.  
  1317.     
  1318.     def _getSpeechForToolBar(self, obj, already_focused):
  1319.         '''Get the speech for a tool bar
  1320.  
  1321.         Arguments:
  1322.         - obj: the tool bar
  1323.         - already_focused: False if object just received focus
  1324.  
  1325.         Returns a list of utterances to be spoken for the object.
  1326.         '''
  1327.         utterances = self._getDefaultSpeech(obj, already_focused)
  1328.         self._debugGenerator('_getSpeechForToolBar', obj, already_focused, utterances)
  1329.         return utterances
  1330.  
  1331.     
  1332.     def _getSpeechForTree(self, obj, already_focused):
  1333.         '''Get the speech for a tree
  1334.  
  1335.         Arguments:
  1336.         - obj: the tree
  1337.         - already_focused: False if object just received focus
  1338.  
  1339.         Returns a list of utterances to be spoken for the object.
  1340.         '''
  1341.         utterances = self._getDefaultSpeech(obj, already_focused)
  1342.         self._debugGenerator('_getSpeechForTree', obj, already_focused, utterances)
  1343.         return utterances
  1344.  
  1345.     
  1346.     def _getSpeechForTreeTable(self, obj, already_focused):
  1347.         '''Get the speech for a tree table
  1348.  
  1349.         Arguments:
  1350.         - obj: the tree table
  1351.         - already_focused: False if object just received focus
  1352.  
  1353.         Returns a list of utterances to be spoken for the object.
  1354.         '''
  1355.         utterances = self._getDefaultSpeech(obj, already_focused)
  1356.         self._debugGenerator('_getSpeechForTreeTable', obj, already_focused, utterances)
  1357.         return utterances
  1358.  
  1359.     
  1360.     def _getSpeechForWindow(self, obj, already_focused):
  1361.         '''Get the speech for a window
  1362.  
  1363.         Arguments:
  1364.         - obj: the window
  1365.         - already_focused: False if object just received focus
  1366.  
  1367.         Returns a list of utterances to be spoken for the object.
  1368.         '''
  1369.         utterances = self._getDefaultSpeech(obj, already_focused)
  1370.         self._debugGenerator('_getSpeechForWindow', obj, already_focused, utterances)
  1371.         return utterances
  1372.  
  1373.     
  1374.     def getSpeech(self, obj, already_focused):
  1375.         '''Get the speech for an Accessible object.  This will look
  1376.         first to the specific speech generators and then to the
  1377.         default speech generator.  This method is the primary method
  1378.         that external callers of this class should use.
  1379.  
  1380.         Arguments:
  1381.         - obj: the object
  1382.         - already_focused: False if object just received focus
  1383.  
  1384.         Returns a list of utterances to be spoken.
  1385.         '''
  1386.         role = obj.getRole()
  1387.         if role in self.speechGenerators:
  1388.             generator = self.speechGenerators[role]
  1389.         else:
  1390.             generator = self._getDefaultSpeech
  1391.         return [
  1392.             ' '.join(generator(obj, already_focused))]
  1393.  
  1394.     
  1395.     def getSpeechContext(self, obj, stopAncestor = None):
  1396.         '''Get the speech that describes the names and role of
  1397.         the container hierarchy of the object, stopping at and
  1398.         not including the stopAncestor.
  1399.  
  1400.         Arguments:
  1401.         - obj: the object
  1402.         - stopAncestor: the anscestor to stop at and not include (None
  1403.           means include all ancestors)
  1404.  
  1405.         Returns a list of utterances to be spoken.
  1406.         '''
  1407.         utterances = []
  1408.         if not obj:
  1409.             return utterances
  1410.         if obj == stopAncestor:
  1411.             return utterances
  1412.         parent = obj.parent
  1413.         while parent and parent.parent != parent:
  1414.             if parent == stopAncestor:
  1415.                 break
  1416.             
  1417.             if not self._script.isLayoutOnly(parent):
  1418.                 text = self._script.getDisplayedLabel(parent)
  1419.                 if not text and 'Text' in pyatspi.listInterfaces(parent):
  1420.                     text = self._script.getDisplayedText(parent)
  1421.                 
  1422.                 if text and len(text.strip()):
  1423.                     if parent.getRole() not in [
  1424.                         pyatspi.ROLE_TABLE_CELL,
  1425.                         pyatspi.ROLE_FILLER]:
  1426.                         utterances.extend(self.getSpeechForObjectRole(parent))
  1427.                     
  1428.                     utterances.append(text)
  1429.                     if parent.getRole() == pyatspi.ROLE_TABLE_CELL:
  1430.                         utterances.extend(self.getSpeechForObjectRole(parent))
  1431.                     
  1432.                 
  1433.             
  1434.             parent = parent.parent
  1435.         utterances.reverse()
  1436.         return utterances
  1437.  
  1438.  
  1439.